home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr48 / vdl020d.zip / SDLPHIGH.DOC < prev    next >
Text File  |  1993-04-14  |  13KB  |  425 lines
  1.  (*===================  S  D  L  P   H I G H   U N I T  ====================
  2.   =                                                                        =
  3.   =  REVISION 1.1                 08/01/90                    J.R. TAYLOR  =
  4.   =                                                                        =
  5.   ==========================================================================
  6.   =                                                                        =
  7.   =  SDLP   Management Library for TP V:4.0, 5.0, 5.5, 6.0                 =
  8.   =                                                                        =
  9.   =  Written By Jonathan Robert Taylor                                     =
  10.   =                                                                        =
  11.   =                                                                        =
  12.   =  This code is the property of Columbia Data Products, Inc.             =
  13.   =  It may be distributed and used outside CDP so long as this header     =
  14.   =  remains intact and unmodified, and as long as it is used with a       =
  15.   =  licensed Standard Device Level Protocol Kernel.                       =
  16.   =                                                                        =
  17.   =  Copyright 1989,1990 Columbia Data Products, Inc.                      =
  18.   =  ALL RIGHTS RESERVED                                                   =
  19.   = ---------------------------------------------------------------------- =
  20.   =  Revision History        Procedures changed; overall purpose of change.=
  21.   =                          Procedure specific revision notes below.      =
  22.   =                          Reverse chronological order.                  =
  23.   = ---------------------------------------------------------------------- =
  24.   =   date    initials   change description                                =
  25.   = ---------------------------------------------------------------------- =
  26.   = 08-30-90    jrt     made getpartinfo work on non-512 media             =
  27.   = 08-05-90    jrt     made sdlpscanunit so that it can re-scan device    =
  28.   = 08-01-90    jrt     Got rid of all references to b[1]                  =
  29.   = 07-16-90    jrt     Started                                            =
  30.   =                                                                        =
  31.   ==========================================================================
  32. *)
  33.  
  34.  
  35. Unit SDLPHIGH;
  36.  
  37. {-------------------------------------------------------------------------}
  38. {                       UNIT SDLPhigh                                     }
  39. {-------------------------------------------------------------------------}
  40. { PURPOSE: High-Level SDLP Library.  This unit provides a complete list   }
  41. { all attached devices with basic information available on each, including}
  42. { device type & name as well as the partitioning data (where it exists)   }
  43. { SOURCE : JR Taylor                                                      }
  44. {-------------------------------------------------------------------------}
  45.  
  46.  
  47. Uses
  48.  
  49.   DOS,
  50.   VSDLPLOW;
  51.  
  52.  
  53. Type
  54.  
  55.   {----------------------------------}
  56.   { SDLPDev -- Info on a SDLP device }
  57.   {----------------------------------}
  58.  
  59.   SDLPDev = RECORD
  60.     UnitNum  : BYTE;
  61.     HAC      : BYTE;
  62.     Target   : BYTE;
  63.     LUN      : BYTE;
  64.     TypeNum  : WORD;
  65.     Blocks   : LONGINT;
  66.     BlockSize: WORD;
  67.     DevSizeB : LONGINT;
  68.     DevSizeM : LONGINT;
  69.     VendorID : Array[1..08] of CHAR;
  70.     ProdName : Array[1..16] of CHAR;
  71.     RevLevel : Array[1..04] of CHAR;
  72.     Name     : STRING[32];
  73.     NumPars  : WORD;
  74.   END;
  75.  
  76.   PtrToSDLPDev = ^SDLPDev;
  77.  
  78.   {------------------------------------------------------}
  79.   { CHAR_BYTE -- Union of character and byte for buffers }
  80.   {------------------------------------------------------}
  81.  
  82.   CHAR_BYTE = RECORD
  83.     Case INTEGER of
  84.       1 : (C:CHAR);
  85.       2 : (B:BYTE);
  86.     END;
  87.  
  88.  
  89. Var
  90.  
  91.   Dev     : Array[1..64] of PtrToSDLPDev;
  92.   NumDev  : WORD;
  93.  
  94. {- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - }
  95.  
  96. Procedure SDLPScanLUN(     SUnit : INTEGER;
  97.                        var DType : BYTE;
  98.                        var Err   : BYTE     );
  99.  
  100. Procedure SDLPScanUnit( UnitNumber : INTEGER );
  101.  
  102. Procedure SDLPScanHAC(  HAC        : INTEGER );
  103.  
  104. Procedure SDLPScanSystem;
  105.  
  106. Procedure Open_SDLPHigh;
  107.  
  108. Procedure Close_SDLPHigh;
  109.  
  110.  
  111. Implementation {===========================================================}
  112.  
  113. {-------------------------------------------------------------------------}
  114. {                       Procedure TestUnitReady                           }
  115. {-------------------------------------------------------------------------}
  116. { IN:  SUnit (INTEGER) SCSI Unit Number (... hhtt tlll)                   }
  117. {  VAR Err (BYTE) operation error code                                    }
  118. { OUT: (none)                                                             }
  119. { Simple test to determine if device exists at the unit number provided.  }
  120. {-------------------------------------------------------------------------}
  121.  
  122. Procedure TestUnitReady(SUnit : INTEGER; VAR Err:BYTE);
  123. VAR
  124.    CDB    : ARRAY[1..6] of BYTE;
  125.    BUF    : ARRAY[1..6] of BYTE;
  126.    Error  : WORD;
  127.    Error2 : WORD;
  128.  
  129. BEGIN
  130.   FillChar( CDB, SizeOf( CDB ), 0 );
  131.  
  132.   Error := InSCSI( SUnit, Addr( CDB ), Addr( Buf ), 6, 0 );
  133.  
  134.   If Error AND $0F = 2 Then
  135.   BEGIN
  136.     CDB[1] := $03;
  137.     CDB[2] := $00;
  138.     CDB[3] := $00;
  139.     CDB[4] := $00;
  140.     CDB[5] := $18;
  141.     CDB[6] := $00;
  142.  
  143.     Error2 := InSCSI( SUnit, Addr( CDB ), Addr( Buf ), 6, 0 );
  144.   END;   { Of Then }
  145.  
  146.   Err := Error;
  147. END;   { Of TestUnitReady }
  148.  
  149. {-------------------------------------------------------------------------}
  150. {                       Procedure SDLPScanLUN                             }
  151. {-------------------------------------------------------------------------}
  152. { IN:  SUnit (INTEGER) target SCSI Unit Number (... hhtt tlll)            }
  153. {  VAR DType (BYTE) returned device Type                                  }
  154. {  VAR Err (BYTE) returned error code                                     }
  155. { OUT: (none)                                                             }
  156. { Detects if the given LUN exists, and if so, Scans the device for all    }
  157. { information.  This data is stored in the Dev structure.                 }
  158. {-------------------------------------------------------------------------}
  159.  
  160. Procedure SDLPScanLUN(     SUnit : INTEGER;
  161.                        var DType : BYTE;
  162.                        var Err   : BYTE     );
  163.  
  164. Var
  165.  
  166.   Z       : INTEGER;
  167.   CDB     : ARRAY[1..12] of BYTE;
  168.   NumB    : LONGINT;
  169.   Bsize   : WORD;
  170.   Buff    : ARRAY[1..40] of CHAR_BYTE;
  171.   dnumdev : INTEGER;
  172.   R,R2    : REAL;
  173.  
  174.  
  175. BEGIN
  176.   {--------------------------------------------}
  177.   { Check for Drive present and if so the type }
  178.   {--------------------------------------------}
  179.  
  180.   SDLP_GetDevInfo( SUnit, TRUE, FALSE, NumB, BSize, DType, Err );
  181.  
  182.   If ( Err = 0 ) AND ( DType < 10 ) OR ( DType = $80 ) Then
  183.   BEGIN
  184.     dnumdev:=-1;
  185.  
  186.     For Z:=1 to NumDev Do
  187.     BEGIN
  188.       if dev[z]^.UnitNum=SUnit Then
  189.         dnumdev:=Z;
  190.     END;
  191.  
  192.     If DNumDev=-1 Then
  193.     BEGIN
  194.       inc(numdev);
  195.       dnumdev:=numdev;
  196.     END;
  197.  
  198.     If Dev[DNumDev]=Nil Then
  199.     BEGIN
  200.       New(Dev[DNumDev]);
  201.     END;
  202.  
  203.     With Dev[DNumDev]^ Do
  204.     BEGIN
  205.       TypeNum:=DType;
  206.       UnitNum:= SUnit;
  207.       HAC    := SUnit SHR 6;
  208.       Target :=(SUnit SHR 3) AND$07;
  209.       Lun    := SUnit AND $07;
  210.     END;
  211.  
  212.     {----------------------}
  213.     { Get the Devices Size }
  214.     {----------------------}
  215.  
  216.     SDLP_GetDevInfo( SUnit, TRUE, TRUE, NumB, BSize, DType, Err);
  217.  
  218.     If Err = 0 Then
  219.     BEGIN
  220.       With Dev[DNumDev]^ Do
  221.       BEGIN
  222.         Blocks:=NumB;
  223.         BlockSize:=BSize;
  224.         DevSizeB:=Blocks*BlockSize;
  225.         DevSizeM:=DevSizeB DIV 1048576;
  226.  
  227.         { ^%^ Jon T Mod 04/21/92 }
  228.  
  229.         R  := Blocks;
  230.         R2 := BlockSize;
  231.  
  232.         DevSizeM:=Round( R * R2 / 1048576.0 );
  233.  
  234.         { End Jon T Mod ^%^ }
  235.  
  236.       END; { With Dev[NumDev]^ }
  237.     END
  238.     ELSE
  239.     BEGIN
  240.       With Dev[DNumDev]^ Do
  241.       BEGIN
  242.         Blocks:=-1;
  243.         BlockSize:=0;
  244.         DevSizeB:=-1;
  245.         DevSizeM:=-1;
  246.       END;
  247.     END;   { if nocarry(r.flags) / else }
  248.  
  249.     CDB[1]:=$12;
  250.     CDB[2]:=$0;
  251.     CDB[3]:=$0;
  252.     CDB[4]:=$0;
  253.     CDB[5]:=$24;
  254.     CDB[6]:=$0;
  255.  
  256.     If InSCSI(Dev[DNumDev]^.UnitNum, Addr(CDB), Addr(Buff), 6, $24)<>0 Then
  257.     BEGIN
  258.  
  259.       { Fill with something here }
  260.  
  261.     END;
  262.  
  263.     With Dev[DNumDev]^ DO
  264.     BEGIN
  265.       For Z:=1 to 8 DO
  266.          VendorID[Z]:=Buff[8+Z].C;
  267.       For Z:=1 to 16 DO
  268.         ProdName[Z]:=Buff[16+Z].C;
  269.       For Z:=1 to 4 DO
  270.         RevLevel[Z]:=Buff[32+Z].C;
  271.       Name:=VendorID+ProdName+RevLevel;
  272.     END; { With Dev[NumDev]^ }
  273.  
  274.     Err := 0;
  275.  
  276.   END; { If Device was found }
  277.  
  278. END;
  279.  
  280. {-------------------------------------------------------------------------}
  281. {                       Procedure SDLPScanUnit                            }
  282. {-------------------------------------------------------------------------}
  283. { IN:  UnitNumber (INTEGER) selected target ID                            }
  284. { OUT: (none)                                                             }
  285. { Scans the LUNs of the given Target for device information               }
  286. {-------------------------------------------------------------------------}
  287.  
  288. Procedure SDLPScanUnit( UnitNumber : INTEGER );
  289.  
  290. Var
  291.    Z     : INTEGER;
  292.    Error : BYTE;
  293.    DType : BYTE;
  294.    Test  : BOOLEAN;
  295.  
  296. BEGIN
  297.  
  298.   Z := -1;
  299.  
  300.   Repeat
  301.  
  302.     {MT_Do( 0 );}
  303.  
  304.     Inc( Z );
  305.  
  306.     SDLPScanLUN( UnitNumber + Z, DType, Error );
  307.  
  308.     Test := NOT ( ( Error = 0 ) AND ( DType < 10 ) OR ( DType = $80 ) );
  309.  
  310.   Until ( Test ) OR ( Z = 7 );
  311.  
  312. END;
  313.  
  314. {-------------------------------------------------------------------------}
  315. {                       Procedure SDLPScanHAC                             }
  316. {-------------------------------------------------------------------------}
  317. { IN:  HAC (INTEGER) target Host Adapter                                  }
  318. { OUT: (none)                                                             }
  319. { Scans each Target ID on the given HAC for device information            }
  320. {-------------------------------------------------------------------------}
  321.  
  322. Procedure SDLPScanHAC( HAC : INTEGER );
  323.  
  324. Var
  325.  
  326.   Z : INTEGER;
  327.  
  328. BEGIN
  329.  
  330.   For Z := 0 to 6 Do
  331.   BEGIN
  332.  
  333.     SDLPScanUnit( ( HAC * 64 ) + ( Z * 8 ) );
  334.  
  335.   END;
  336.  
  337. END;
  338.  
  339. {-------------------------------------------------------------------------}
  340. {                       Procedure SDLPScanSystem                          }
  341. {-------------------------------------------------------------------------}
  342. { IN:  (none)                                                             }
  343. { OUT: (none)                                                             }
  344. { Checks that SDLP exists and if so Scans entire system for device        }
  345. { information                                                             }
  346. {-------------------------------------------------------------------------}
  347.  
  348. Procedure SDLPScanSystem;
  349.  
  350. Var
  351.  
  352.   VerNum : BYTE;
  353.   NumHAC : BYTE;
  354.   Err    : BYTE;
  355.   RamRes : BOOLEAN;
  356.   Z      : BYTE;
  357.  
  358. BEGIN
  359.  
  360.   Repeat
  361.  
  362.     SDLP_SysIdent( VerNum, RamRes, NumHAC, Err );
  363.  
  364.   Until Err <> 4;
  365.  
  366.   If Err=0 Then
  367.     For Z := 1 to NumHAC Do
  368.       SDLPScanHac(Z-1);
  369.  
  370. END;
  371.  
  372.  
  373. {-------------------------------------------------------------------------}
  374. {                       Procedure Open_SDLPHIGH                           }
  375. {-------------------------------------------------------------------------}
  376. { IN:  (none)                                                             }
  377. { OUT: (none)                                                             }
  378. { Initializes all the structures and scans the bus to find all devices.   }
  379. { data is stored in the Dev Structure.                                    }
  380. {-------------------------------------------------------------------------}
  381.  
  382.  
  383. Procedure Open_SDLPHIGH;
  384.  
  385. BEGIN
  386.  
  387.   SDLPScanSystem;
  388.  
  389. END;
  390.  
  391. {-------------------------------------------------------------------------}
  392. {                       Procedure Close_SDLPHIGH                          }
  393. {-------------------------------------------------------------------------}
  394. { IN:  (none)                                                             }
  395. { OUT: (none)                                                             }
  396. { Does nothing for DOS, but exists for compatibility to other OS platforms}
  397. {-------------------------------------------------------------------------}
  398.  
  399.  
  400. Procedure Close_SDLPHigh;
  401.  
  402. BEGIN
  403.   {----------------------------------}
  404.   { no actions need be taken for DOS }
  405.   {----------------------------------}
  406. END;
  407.  
  408.  
  409. {-------------------------------------------------------------------------}
  410. {                       Unit SDLPHigh                                     }
  411. {-------------------------------------------------------------------------}
  412.  
  413. BEGIN
  414.  
  415.   For NumDev:=1 to 64 Do
  416.   BEGIN
  417.     Dev[NumDev]:=NIL;
  418.   END;
  419.  
  420.   NumDev:=0;
  421.  
  422. END.
  423.  
  424.  
  425.